/*
    poll 模型实现网络通讯的服务端

    存在问题
        1、poll的数据结构是数组，传入内核转换成了链表
        2、每调用一次select()需要拷贝两次bitmap(拷贝临时bitmap，select中拷贝给内存一次)，pool拷贝一次结构体数组
        3、poll监听的连接没有1024的限制，但是也用遍历方法，监听socket越多，效率越低
*/
#include <iostream>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>

// 初始化服务端的监听端口
int initserver(int port);

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cout << "Usgae:./tcppoll port" <<std::endl;
        return -1;
    }
    
    // 初始化服务端用于监听的socket
    int listen_sock = initserver(std::atoi(argv[1]));
    std::cout << "listen_sock=" << listen_sock <<std::endl;

    if (listen_sock < 0)
    {
        std::cout << "initserver() failed" <<std::endl;
        return -1;
    }
    /*
        读事件
            1、已连接队列中有已经准备好的socket（有新的客户端连上来了）
            2、接收缓存中有数据可以读（对端发送的报文已到达）
            3、tcp连接一下已断开（对端调用close函数关闭了连接）
        写事件
            发送缓冲区没有满，可以写入数据（可以向对端发送报文）
    */
    
    // fds存放要监听的socket，如果只监听一个socket，可以不适用数组，只用fds即可
    pollfd fds[1024];
    // 此处不能使用memset初始化
    for (int i = 0; i < 1024; i++)
    {
        // 初始化数组，把全部的socket置为01，如果数组中的socket值为-1，poll将忽略它
        fds[i].fd = -1;
    }
    
    // 让poll监听listen_sock读事件
    fds[listen_sock].fd = listen_sock;
    fds[listen_sock].events = POLLIN;
    // POLLIN 读事件，POLLOUT 写事件 同时监听读与写事件
    // fds[listen_sock].events = POLLIN|POLLOUT;

    // fds数组中要监视socket的实际大小
    int max_fd = listen_sock;

    while (true)
    {
        // 调用poll等待时间的发生  超时时间为10s
        int infds = poll(fds, max_fd+1, 10000);

        if (infds < 0)
        {
            // 调用poll失败
            perror("poll() failed");
            break;
        }
        
        if (infds == 0)
        {
            // poll() 超时
            perror("poll() timeout");
            continue;
        }
        
        // 如果infds>0 表示有事件发生，infds存放了发生事件的个数
        for (int event_fd = 0; event_fd <= max_fd; event_fd++)
        {
            if (fds[event_fd].fd < 0)
            {
                // fd为负，忽略
                continue;
            }
            
            if ((fds[event_fd].revents & POLLIN) == 0)
            {
                // 没有读事件
                continue;
            }
            
            if (event_fd == listen_sock)
            {
                // 如果发生事件的是listensock 表示已连接队列中有已准备好的socket(有新的客户端连上来了)
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int client_sock = accept(listen_sock, (struct sockaddr *)&client, &len);
                if (client_sock < 0)
                {
                    perror("accept failed");
                    continue;
                }
                std::cout << "accept client(socket=)" << client_sock <<std::endl;

                // 修改fds数组中client_sock位置的元素
                fds[client_sock].fd = client_sock;
                fds[client_sock].events = POLLIN;

                if (max_fd < client_sock)
                {
                    // 更新max_fd值
                    max_fd = client_sock;
                }
            }
            else
            {
                // 如果是客户端连接的socket有事件，表示接受缓存中有数据可以读(对端发送的报文已到达)，或者有客户端已断开连接
                char buffer[1024];
                memset(buffer, 0, sizeof(buffer));
                if (recv(event_fd, buffer, sizeof(buffer), 0) <= 0)
                {
                    // 如果客户端的连接已断开
                    std::cout << "client(event_fd="  << event_fd << ") disconnected" <<std::endl;
                    // 关闭客户端的socket
                    close(event_fd);

                    // 修改fds数组中client_sock位置的元素
                    fds[event_fd].fd = -1;

                    if (event_fd == max_fd)
                    {
                        // 更新max_fd的值，只有当event_fd == max_fd时才更新
                        for (int i = max_fd; i>0; i--)
                        {
                            if (fds[i].fd != -1)  
                            {
                                // 当前bit在bitmap中被设置
                                max_fd = i;
                                break;
                            }   
                        }   
                    }
                }
                else
                {
                    std::cout << "recv(event_fd=" << event_fd << ":" << buffer <<std::endl;
                    send(event_fd, buffer, strlen(buffer), 0);  // 将接受到的消息原发送回去
                }
            }
        }
    }
    return 0;
}


int initserver(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    if (sock < 0)
    {
        perror("socket() failed");
        return -1;
    }
    
    int opt = 1;
    unsigned int len = sizeof(opt);
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, len);

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        perror("bind() failed");
        return -1;
    }
    
    if (listen(sock, 5) != 0)
    {
        perror("listen() failed");
        return -1;
    }
    return sock;
}
